/*
 * @Author: zhongPlee info@witop.cn
 * @Date: 2024-07-15 20:12:48
 * @LastEditors: zss
 * @LastEditTime: 2024-11-15 17:30:21
 * @FilePath: \xf\src\services\PersonalPreference\index.ts
 * @Description:
 * */

import { N_userPrefTemplate } from '@/components/base/modal/o-user-pref/types';
import { I_srv, ifs, ts } from '@/services';
import store from '@/store';
// 操作行为枚举
// eslint-disable-next-line no-shadow
export enum V_action {
  // 档位顺序拖动
  DRAG = 0,
  // 字段显示设定
  SHOW_TABLE_COLUMN
}

interface storeData {
  resizableData?: Object;
  sortData?: Object;
  visibleData?: Object;
  fixedData?: Object;
}
interface tableBehavior {
  id: string;
  type: string;
  storeData: storeData;
}

interface I_behavior {
  key: string;
  value: tableBehavior;
}

interface I_layoutRecord {
  path: string;
  value: string;
}

interface I_layoutInfos {
  mainFun: string;
  layout: I_layoutRecord[];
}

interface I_behaviorData {
  mainFunName: string;
  funBehaviors: I_behavior[];
  layoutRecord: I_layoutRecord[] | null; // 布局记录
}
export interface I_template {
  id?: string;
  title: string;
  _sys_user_id: string;
  f_type: number;
  f_data: string;
  classification: number;
  f_comment: string | null;
  preview: string | null;
}

export class T_personalPreference {
  private srv: I_srv;

  static styleMatch: any = () => {
    return new Map(
      Object.entries({
        '--global-font-family': 'global.fontFamily',
        /* 左侧导航部分（项目名部分和导航部分） */
        // 导航背景颜色
        '--nav-bg-color': 'home.nav.firstNav.bgc',
        // 导航字体颜色
        '--nav-font-color': 'home.nav.firstNav.fontColor',
        // 导航背景悬停颜色
        '--nav-hover-bg-color': 'home.nav.firstNav.hoverBgc',
        '--nav-hover-font-color': 'home.nav.firstNav.hoverFontColor',

        '--nav-title-bg-color': 'home.nav.title.bgc', // logo区域背景色
        '--nav-title-font-color': 'home.nav.title.fontColor', // logo区域字体颜色
        '--nav-title-hover-bg-color': 'home.nav.title.hoverBgc', // logo区域悬浮背景色

        '--navSub-bg-color': 'home.nav.secondNav.bgc',
        '--navSub-font-color': 'home.nav.secondNav.fontColor',
        '--navSub-hover-bg-color': 'home.nav.secondNav.hoverBgc',
        '--navSub-hover-font-color': 'home.nav.secondNav.hoverFontColor',
        // 顶部功能
        '--top-bg-color': 'home.top.bgc',
        '--top-font-color': 'home.top.fontColor',
        '--top-btn-hover-bg-color': 'home.top.hoverBgc',
        '--top-btn-hover-font-color': 'home.top.hoverFontColor',
        // 主体部分的主内容区域（不包括面包屑）
        '--main-content-bg-color': 'home.main.contentBgc',
        // tabs组件
        '--tabs-bg-color': 'home.tabs.bgc',
        '--tabpane-font-color': 'home.tabs.fontColor',
        '--tabpane-hover-font-color': 'home.tabs.hoverFontColor',
        '--tabpane-active-font-color': 'home.tabs.activeFontColor',

        /* basegrid 变量 */
        '--basegrid-toolbar-bg-color': 'components.basegrid.toolbarBgc', // toolbar背景颜色
        // '--basegrid-toolbar-btn-fontColor': '#515a6e', // toolbar字体、图标颜色
        '--basegrid-toolbar-btn-hover-font-color':
          'components.basegrid.toolbarBtnHoverFontColor', // toolbar字体、图标hover颜色
        '--basegrid-toolbar-btn-hover-bg-color':
          'components.basegrid.toolbarBtnHoverBgc',
        /* vxe-table 变量 */
        '--table-thead-bg-color': 'components.basegrid.theadBgc', // table头部行背景
        '--table-row-striped-bg-color': 'components.basegrid.rowStripedBgc', // striped行的颜色
        '--table-row-current-bg-color': 'components.basegrid.rowCurrentBgc', // 当前行的颜色
        '--table-row-checked-bg-color': 'components.basegrid.rowCheckedBgc', // 选中行的背景
        '--table-background-color': 'components.basegrid.tableBgc',
        '--table-footer-bg-color': 'components.basegrid.footerBgc',

        /* baseform 变量 */
        '--form-bg-color': 'components.baseform.bgc', // toolbar背景颜色
        '--collapse-header-bgcolor': 'components.baseform.collapseHeaderBgc', // toolbar背景颜色

        /* basepanel 变量 */
        '--basepanel-toolbar-bg-color': 'components.basepanel.toolbarBgc', // toolbar背景颜色
        '--basepanel-toolbar-btn-hover-font-color':
          'components.basepanel.toolbarBtnHoverFontColor', // toolbar字体、图标hover颜色
        '--basepanel-toolbar-btn-hover-bg-color':
          'components.basepanel.toolbarBtnHoverBgc', // toolbar字体、图标hover颜色

        /* multiform 变量 */
        '--multiform-toolbar-bg-color': 'components.multiform.toolbarBgc', // 背景颜色
        '--multiform-toolbar-hover-font-color':
          'components.multiform.toolbarBtnHoverFontColor', // 字体、图标颜色

        /* treegrid 变量 */
        '--treegrid-toolbar-bg-color': 'components.treegrid.toolbarBgc', // toolbar背景颜色
        '--treegrid-toolbar-btn-hover-font-color':
          'components.treegrid.toolbarBtnHoverFontColor', // toolbar字体、图标hover颜色
        '--treegrid-toolbar-btn-hover-bg-color':
          'components.treegrid.toolbarBtnHoverBgc', // toolbar字体、图标hover颜色

        // date-nav
        '--date-nav-bg-color': 'components.dateNav.bgc',
        '--date-nav-title-bg-color': 'components.dateNav.titleBgc',
        '--date-nav-calendar-bg-color': 'components.dateNav.calendarBgc',

        // 画布
        '--graph-toolbar-font-color': 'components.graph.toolbarBtnFontColor',
        '--graph-toolbar-hover-font-color':
          'components.graph.toolbarBtnHoverFontColor',
        '--graph-toolbar-hover-bg-color': 'components.graph.toolbarBtnHoverBgc',
        '--graph-toolbar-disabled-font-color':
          'components.graph.toolbarBtnDisabledFontColor',

        // model
        '--model-bg-color': 'components.modal.bgc'
      })
    );
  };

  private PPUIConfs: Map<string, any> = new Map(); // 存储用户喜好配置

  // private PPBehaviorConfs: Map<string, I_template> = new Map(); // 存储用户喜好配置

  private PPBehaviorConf: I_template = {
    id: '',
    title: store.state.User.userNo,
    _sys_user_id: '',
    f_type: 1,
    f_data: '',
    classification: 1,
    f_comment: null,
    preview: null
  };

  private defalutStyleConf: any;

  private defaultUITempId: string; // 用户默认模版配置ID

  private userDefaultTempID: string; // 用户默认模版配置该项数据ID

  private currentUITempID: string = 'default'; // 当前选中的用户喜好配置ID

  private beHaviorData: I_behaviorData[] = []; // 各功能行为数据

  private behaviorStatus: boolean = false; // 是否开启行为记录

  private localStatus: boolean = false; // 本地属性是否存在新增或删除

  constructor(srv: I_srv) {
    this.srv = srv;
  }

  /**
   * @Author: swc
   * @return {*}
   * @description: 初始化用户喜好配置
   */
  public PPInit() {
    return new Promise((resolve, reject) => {
      // 1、对比本地 root变量的值 与 数据库存的 默认配置是否一致，不一致进行同步
      const defalutStyleConf = new N_userPrefTemplate().f_data;
      const rootStyle = getComputedStyle(document.documentElement);

      const styleMatch = T_personalPreference.styleMatch();

      for (const [key, value] of styleMatch) {
        this.srv.utils.setObjValByPath(
          defalutStyleConf,
          value,
          rootStyle.getPropertyValue(key)
        );
      }
      this.defalutStyleConf = this.srv.utils.clone(defalutStyleConf, true);

      // this.getPersonalConfig();
      this.getPPConfig().then(async (Response: any[]) => {
        // 1、对比本地 root变量的值 与 数据库存的 默认配置是否一致，不一致进行同步
        // let status: boolean = false;
        const diff = [];
        this.PPUIConfs.forEach(item => {
          const data = JSON.parse(item.f_data);
          // 如果在本地新增一个属性，刷新数据库json
          for (const [key, value] of styleMatch) {
            if (this.srv.utils.get(data, value, 'default') === 'default') {
              this.setObjValByPath(
                data,
                value,
                rootStyle.getPropertyValue(key)
              );
              this.localStatus = true;
            }
          }
          // 如果在本地删除一个属性，刷新数据库json
          this.removeObjKeyByDiff(defalutStyleConf, data);

          item.f_data = JSON.stringify(data);
          diff.push(item);
        });
        // 2、同步到数据库
        if (this.localStatus) {
          this.saveTemplateMany(diff).catch(error => {
            reject(error);
          });
        }
        // 2、获取当前用户选中的 用户喜好配置（如果没有则用默认那套） 设置 “皮肤与动作”————（1、系统默认模版配置，2、用户默认模版配置，3、用户喜好配置）
        // localStorage.getItem('preference') || 'getUserInfo().preference' || 'default'; // ☆☆☆
        const gpd = new ts.T_getPartDataArg();
        const filter = {
          $or: [
            { _sys_user_id: { $in: [this.srv.getUserID()] } },
            { template_type: { $in: [0] } }
          ]
        };
        gpd
          .setFilter(filter)
          .setFunName(this.srv.globalVar.funName.SYS_DEF_TEMP_SET)
          .setTableName(this.srv.globalVar.funName.SYS_DEF_TEMP_SET)
          .setDbType(this.srv.globalVar.dbType.MYSQL)
          .setLang(this.srv.store.state.App.language)
          .setRule({} as ifs.I_rule);
        gpd.setPage(1, 99999);
        const [b, res, rows, err] = await this.srv.getData(gpd);
        // let PPID = localStorage.getItem('preference') || 'default';
        let PPID: any;
        if (b) {
          let viewTempId: any; // 该用户 默认 UI id
          // let userDefaultTemp: any;
          // let sysDefaultTemp: any;

          const sysDefaultTemp = this.srv.utils.find(
            rows,
            item => item.template_type === 0
          );
          const userDefaultTemp = this.srv.utils.find(
            rows,
            item =>
              item._sys_user_id === this.srv.getUserID() &&
              item.template_type === 1
          );

          if (!this.srv.noValue(userDefaultTemp)) {
            this.userDefaultTempID = userDefaultTemp.id;
            viewTempId = userDefaultTemp?.ui_id;
          }

          if (
            this.srv.noValue(userDefaultTemp?.ui_id) &&
            !this.srv.noValue(sysDefaultTemp?.ui_id)
          ) {
            // this.userDefaultTempID = sysDefaultTemp.id;
            viewTempId = sysDefaultTemp?.ui_id;
          }
          // 有配置好的 默认的用户喜好模版 则使用
          this.defaultUITempId = viewTempId;
          PPID = this.defaultUITempId;
          if (
            !this.srv.noValue(this.defaultUITempId) &&
            this.PPUIConfs.has(PPID)
          ) {
            this.currentUITempID = PPID;
            this.updateStyle(this.currentUITempID);
          }
        }
      });
    });
  }

  private removeObjKeyByDiff(newObj: any, oldObj: any) {
    const newKeys = Object.keys(newObj);
    const oldKeys = Object.keys(oldObj);
    const diffKeys = new Set(
      [...newKeys, ...oldKeys].filter(
        x => !newKeys.includes(x) || !oldKeys.includes(x)
      )
    ); // 找出差异的键
    if (diffKeys.size !== 0) {
      this.localStatus = true;
      diffKeys.forEach(key => {
        if (Object.prototype.hasOwnProperty.call(oldObj, key)) {
          delete oldObj[key];
        }
      });
    }

    newKeys.forEach(key => {
      if (typeof newObj[key] === 'object' && newObj[key] !== null) {
        oldObj[key] = this.removeObjKeyByDiff(newObj[key], oldObj[key] || {});
      }
    });
    return oldObj;
  }

  /**
   * @description: 根据路径设置对象值，如果路径不存在则创建路径
   * @param {any} obj
   * @param {string} path
   * @param {any} value
   * @return {boolean}
   * @author: swc
   * @Date: 2024-08-16 16:50:18
   * @LastEditors: zss
   * @LastEditTime: Do not edit
   */
  private setObjValByPath(obj: any, path: string, value: any): boolean {
    const keys = path.split('.'); // 将路径拆分为键数组
    // 递归函数，用于在对象中设置路径对应的值
    function setValue(o: any, k: string[], val: any): boolean {
      if (k.length === 1) {
        o[k[0]] = val; // 已经遍历完路径，设置最终值
        return true;
      }
      const key = keys.shift(); // 取出第一个键
      if (o && typeof o === 'object' && key in o) {
        return setValue(o[key], k, val); // 继续递归设置下一个键
      }
      if (!o[key]) {
        // 如果当前键不存在，则创建一个空对象
        o[key] = {};
        return setValue(o[key], k, val); // 继续递归设置下一个键
      }
      return false;
    }
    return setValue(obj, keys, value);
  }

  /**
   * @Author: swc
   * @return {*}
   * @description: 获取公用配置模板
   */
  public getDefConfig() {
    const DefTemp = [];
    for (const [key, value] of this.PPUIConfs) {
      if (value['f_type'] === 0) {
        DefTemp.push(value);
      }
    }
    return DefTemp;
  }

  /**
   * @Author: swc
   * @return {*}
   * @description: 获取个人配置模板
   */
  public getPersonalConfig() {
    // this.PPUIConfs
    const personalTemp = [];
    for (const [key, value] of this.PPUIConfs) {
      if (value['_sys_user_id'] === this.srv.getUserID()) {
        personalTemp.push(value);
      }
    }
    return personalTemp;
  }

  // 通过功能名获取该表行为配置，
  // 表格使用行为数据
  // 表格新增行为数据，在表格销毁前保存到类里面
  // 表格销毁后，主页点击删除页签，保存功能行为数据到配置表

  /**
   * @description: 通过功能名获取对应行为数据
   * @param {funNames} 主功能名-子功能名
   * @return {null | tableBehavior}
   * @author: swc
   * @Date: 2024-08-07 15:51:18
   * @LastEditors: zss
   * @LastEditTime: Do not edit
   */
  public getFunBehaviorByFunName(funNames: string): tableBehavior | null {
    // this.beHaviorData = JSON.parse(this.getPerBehaviorConfig().f_data);
    if (this.srv.noValue(this.beHaviorData)) return null;
    const names = funNames.split('-');
    let obj = null;
    this.beHaviorData.forEach(el => {
      if (el.mainFunName === names[0]) {
        el.funBehaviors.forEach(fun => {
          if (fun.key === names[1]) obj = fun.value;
        });
      }
    });
    return obj;
  }

  /**
   * @description:
   * @param {mainFunName} 主功能名
   * @return {*}
   * @author: swc
   * @Date: 2024-08-07 16:50:45
   * @LastEditors: zss
   * @LastEditTime: Do not edit
   */
  public recordBehaviorData(mainFunName: string, data: I_behavior): void {
    this.behaviorStatus = true;
    // 如果该用户没有行为数据，则新建
    if (this.srv.noValue(this.beHaviorData)) {
      this.beHaviorData = [
        {
          mainFunName,
          funBehaviors: [data],
          layoutRecord: null
        }
      ];
    } else {
      // 存在行为数据则修改f_data
      this.beHaviorData.forEach((el, index: number, arr) => {
        // 判断是否在同一个主功能下 ,不在则新建，在则修改
        if (arr.filter(fun => fun.mainFunName === mainFunName).length === 0) {
          arr.push({
            mainFunName,
            funBehaviors: [data],
            layoutRecord: null
          });
        } else {
          if (el.mainFunName === mainFunName) {
            el.funBehaviors.forEach((subFun, _, arr1) => {
              // 判断是否存在该子功能，存在则修改，不存在则新增
              if (
                arr1.filter(subFun1 => subFun1.key === data.key).length === 0
              ) {
                arr1.push(data);
              } else {
                if (subFun.key === data.key) subFun.value = data.value;
              }
            });
          }
        }
      });
    }
  }

  public saveBehaviorData(): Promise<boolean> {
    return new Promise((resolve, reject) => {
      if (!this.behaviorStatus) {
        resolve(null);
      } else {
        this.PPBehaviorConf.f_data = JSON.stringify(this.beHaviorData);
        this.saveTemplate(this.PPBehaviorConf, 1).catch(err => reject(err));
        this.behaviorStatus = false;
      }
    });
  }

  /**
   * @Author: swc
   * @return {*}
   * @description: 获取配置模板（系统、当前用户）
   */
  private getPPConfig() {
    return new Promise((resolve, reject) => {
      // const _store = this.srv.getStore();
      // store.state.User.userID // userNo 、userID、userName、dbName、token
      const gpd = new ts.T_getPartDataArg();
      const Tfilter = {
        $or: [
          { _sys_user_id: { $in: [store.state.User.userID] } },
          { f_type: { $in: [0] } }
        ]
      };
      gpd
        .setFilter(Tfilter)
        .setFunName(this.srv.globalVar.tableName.SYS_USER_PREFE)
        .setTableName(this.srv.globalVar.tableName.SYS_USER_PREFE)
        // .setFunName('test1_user_prefe')
        // .setTableName('test1_user_prefe')
        .setDbType(this.srv.globalVar.dbType.MYSQL)
        .setLang(this.srv.store.state.App.language)
        .setRule({} as ifs.I_rule);
      gpd.setPage(1, 99999);
      // const [b, res, rows, err] = await this.srv.getData(gpd);
      this.srv.getData(gpd).then(([b, res, rows, err]) => {
        if (b) {
          rows.forEach(el => {
            if (el?.classification === 0) {
              this.PPUIConfs.set(el.id, el);
            } else if (el?.classification === 1) {
              // this.PPBehaviorConfs.set(el.id, el);
              for (const key in this.PPBehaviorConf) {
                this.PPBehaviorConf[key] = el[key];
              }
              this.beHaviorData = JSON.parse(el.f_data);
            }
          });
          resolve(rows);
        } else {
          reject(err ?? res.msg);
        }
      });
    });
  }

  /**
   * @Author: swc
   * @param {string} PPID 用户喜好模版ID
   * @return {*}
   * @description: 更新全局样式 通过 “用户喜好模版名称”
   */
  public updateGlobalStyle(PPID: string) {
    return new Promise((resolve, reject) => {
      if (PPID === 'default' || !this.PPUIConfs.has(PPID)) {
        return;
      }

      if (this.currentUITempID !== PPID) {
        this.updateDefaultUITempId(PPID)
          .then(_ => {
            resolve(true);
            this.updateStyle(PPID);
            this.currentUITempID = PPID;
          })
          .catch(err => {
            reject(err);
          });
      }
    });
  }

  /**
   * @description: 更新样式
   * @param {string} PPID
   * @return {*}
   * @author: zss
   * @Date: 2024-11-15 17:28:51
   * @LastEditors: zss
   * @LastEditTime: Do not edit
   */
  private updateStyle(PPID: string) {
    let PPUIConfs = this.PPUIConfs.get(PPID);
    if (this.srv.utils.isJSONString(PPUIConfs.f_data)) {
      PPUIConfs = JSON.parse(PPUIConfs.f_data);
    }
    const styleMatch = T_personalPreference.styleMatch();
    for (const [key, value] of styleMatch) {
      document.documentElement.style.setProperty(
        key,
        this.srv.utils.getObjValByPath(PPUIConfs, value)
      );
    }
  }

  /**
   * @Author: swc
   * @param {string} PPID 用户喜好UI模版名称
   * @return {*}
   * @description: 模板指定
   */
  public template(PPID: string) {
    return new Promise((resolve, reject) => {
      if (this.PPUIConfs.has(PPID)) {
        // 1、更新全局样式
        this.updateGlobalStyle(PPID)
          .then(res => {
            if (res) {
              // 修改 store、localstorge、userinfo等
              resolve(true);
            }
          })
          .catch(err => {
            reject(err);
          });
        // 2、更新用户喜好模版————layout
      } else {
        // 没有模板
        reject('没有模板');
      }
    });
  }

  // 值范围处理
  public valueRange() {}

  /**
   * @Author: swc
   * @param {object} template 用户喜好模版{id、 title 、 _sys_user_id 、 classification 、 f_type 、 f_data 、 f_comment}
   * @param {object} type 0： UI模板 1：行为模板
   * @return {*}
   * @description: 保存模板
   */
  public saveTemplate(template: I_template, type: number = 0) {
    return new Promise((resolve, reject) => {
      if (
        template['f_type'] === 0 &&
        this.srv.store.state.sysInfo.roleInfo[0].roleType !== 1
      ) {
        reject('没有权限');
        return;
      }
      template['f_type'] === 0
        ? (template['_sys_user_id'] = null)
        : (template['_sys_user_id'] = this.srv.getUserID());
      // type === 1 && (template['title'] = '');
      const ctd = new ts.T_ctdArg();
      ctd
        .setTableName(this.srv.globalVar.tableName.SYS_USER_PREFE)
        // .setTableName('test1_user_prefe')
        .setFunName(this.srv.globalVar.tableName.SYS_USER_PREFE)
        // .setTableName('test1_user_prefe')
        .setDbType(this.srv.globalVar.dbType.MYSQL)
        .setRule({} as ifs.I_rule);
      if (this.srv.noValue(template['id'])) {
        const insertRecords = [
          [
            { field: 'id', value: this.srv.getSnowIDFmtStr() },
            { field: '_sys_user_id', value: template['_sys_user_id'] },
            { field: 'title', value: template['title'] },
            { field: 'f_type', value: template['f_type'] },
            // { field: 'content', value: template['content'] },
            { field: 'classification', value: template['classification'] },
            { field: 'f_data', value: template['f_data'] },
            { field: 'f_comment', value: template['f_comment'] },
            { field: 'preview', value: template['preview'] }
          ]
        ]; // ifs.I_fv[]
        const scope = {};
        const bDatas: ifs.I_baseData[] = [];
        insertRecords.forEach(ele => {
          const bData = new ts.T_baseData();
          bData
            .setDataRule({} as ifs.I_rule)
            .setFileInfo({})
            .setRowData(...(ele as ifs.I_fv[]));
          bDatas.push(bData);
        });
        ctd.setInsRecDataMany(scope, ...bDatas);
      } else {
        let filter: any = {};
        const ctdUpdDatas: ifs.I_ctdUpdData[] = [];
        const ctdUpdData = new ts.T_ctdUpdData();
        ctdUpdData.setDataRule({} as ifs.I_rule).setFileInfo({});
        const changeData: ifs.I_fv[] = [];
        Object.keys(template).forEach(key => {
          if (key === 'id') {
            filter = { id: template['id'] };
          } else {
            changeData.push({ field: key, value: template[key] } as ifs.I_fv);
          }
        });
        ctdUpdData.setFilter(filter);
        ctdUpdData.setRowData(...changeData);
        ctdUpdDatas.push(ctdUpdData);
        ctd.setUpdRecDataMany(...ctdUpdDatas);
      }
      this.srv.batRows(ctd).then(resp => {
        const [b, res, msg] = resp;
        if (b) {
          this.getPPConfig().then(r => {
            if (typeof r === 'string') {
              console.info(r);
            }
            if (
              !this.srv.noValue(template['id']) &&
              this.currentUITempID === template['id']
            ) {
              this.template(template['id']);
            }
            resolve(msg);
          });
        } else {
          reject(msg);
        }
      });
    });
  }

  /**
   * @Author: swc
   * @param {object} template 用户喜好模版{id、 title 、 _sys_user_id 、 classification 、 f_type 、 f_data 、 f_comment}
   * @return {*}
   * @description: 删除模板
   */
  public deleteTemplate(template: object) {
    return new Promise((resolve, reject) => {
      if (
        template['f_type'] === 0 &&
        this.srv.store.state.sysInfo.roleInfo[0].roleType !== 1
      ) {
        reject('不能删除默认模板');
        return;
      }
      const delRec = new ts.T_ctdDelRec();
      delRec.setRule({} as ifs.I_rule);
      const filter = { id: { $in: [template['id']] } };
      delRec.setFilter(filter);
      this.srv
        .delRows(
          this.srv.globalVar.tableName.SYS_USER_PREFE,
          this.srv.globalVar.dbType.MYSQL,
          {} as ifs.I_rule,
          delRec
        )
        // this.srv.delRows('test1_user_prefe', this.srv.globalVar.dbType.MYSQL, {} as ifs.I_rule, delRec)
        .then(resp => {
          const [b, res, msg] = resp;
          // msg && this.$msg(msg);
          if (b) {
            if (
              this.currentUITempID === template['id'] &&
              !this.srv.noValue(this.defaultUITempId)
            ) {
              this.template(this.defaultUITempId);
            }
            resolve(msg);
            // 修改 用户喜好 配置
            this.PPUIConfs.delete(template['id']);
            // 如果当前删的模版正在使用，则切换到默认模版
          } else {
            reject(msg);
          }
        });
    });
  }

  /**
   * @Author: swc
   * @param {string} id 用户喜好默认UI模版id
   * @return {*}
   * @description: 删除模板
   */
  private updateDefaultUITempId(id: string) {
    return new Promise((resolve, reject) => {
      const ctd = new ts.T_ctdArg();
      ctd
        .setTableName(this.srv.globalVar.funName.SYS_DEF_TEMP_SET)
        .setTableName(this.srv.globalVar.funName.SYS_DEF_TEMP_SET)
        .setDbType(this.srv.globalVar.dbType.MYSQL)
        .setRule({} as ifs.I_rule);
      // if (this.srv.noValue(this.defaultUITempId)) {
      if (this.srv.noValue(this.userDefaultTempID)) {
        const insertRecords = [
          [
            { field: 'id', value: this.srv.getSnowIDFmtStr() },
            { field: 'template_type', value: 1 }, // 用户
            { field: '_sys_user_id', value: this.srv.getUserID() },
            { field: 'ui_id', value: id },
            { field: 'behavior_Id', value: '' }
          ]
        ]; // ifs.I_fv[]
        const scope = {};
        const bDatas: ifs.I_baseData[] = [];
        insertRecords.forEach(ele => {
          const bData = new ts.T_baseData();
          bData
            .setDataRule({} as ifs.I_rule)
            .setFileInfo({})
            .setRowData(...(ele as ifs.I_fv[]));
          bDatas.push(bData);
        });
        ctd.setInsRecDataMany(scope, ...bDatas);
      } else {
        let filter: any = {};
        const ctdUpdDatas: ifs.I_ctdUpdData[] = [];
        const ctdUpdData = new ts.T_ctdUpdData();
        ctdUpdData.setDataRule({} as ifs.I_rule).setFileInfo({});
        const changeData: ifs.I_fv[] = [];
        filter = { id: this.userDefaultTempID };
        changeData.push({ field: 'ui_id', value: id } as ifs.I_fv);
        ctdUpdData.setFilter(filter);
        ctdUpdData.setRowData(...changeData);
        ctdUpdDatas.push(ctdUpdData);
        ctd.setUpdRecDataMany(...ctdUpdDatas);
      }
      this.srv.batRows(ctd).then(resp => {
        const [b, res, msg] = resp;
        // msg && this.$msg(msg);
        if (b) {
          // const msge = vue.prototype.$Message.info({
          //   content: this.srv.getI18nByValue('保存成功'),
          //   duration: 3,
          //   closable: true
          // });
          // msge();
          // this.PPUIConfs.set(template['id'], template);
          this.getPPConfig()
            .then(r => {
              if (typeof r === 'string') {
                console.info(r);
              }
              if (!this.srv.noValue(id) && this.currentUITempID === id) {
                this.template(id);
              }
              resolve(msg);
            })
            .catch(err => {
              reject(err);
            });
        } else {
          reject(msg);
        }
      });
    });
  }

  // 组件行为初始化
  public componentInit() {}

  // 监听 操作行为
  public listenAction() {}

  // 获取

  /**
   * @Author: swc
   * @return {*} defalutStyleConf
   * @description: 获取当前root 默认喜好模版——view部分
   */
  public getDevfPPView() {
    return JSON.stringify(this.defalutStyleConf);
  }

  /**
   * @Author: swc
   * @return {*} PPConf
   * @description: 获取模版配置数据（通过模版ID）
   */
  public getTemplateById(id: string) {
    return this.PPUIConfs.get(id);
  }

  /**
   * @Author: swc
   * @return {*} currentUITempID
   * @description: 获取当前 UI模版配置 ID
   */
  public getCurrentUITempID() {
    return this.currentUITempID;
  }

  /**
   * @description: 同步本地新增模板数据
   * @param {*} const
   * @return {*}
   * @author: swc
   * @Date: 2024-08-03 13:40:59
   * @LastEditors: zss
   * @LastEditTime: Do not edit
   */
  private saveTemplateMany(rows: any[]) {
    return new Promise((resolve, reject) => {
      const ctd = new ts.T_ctdArg();
      ctd
        .setTableName(this.srv.globalVar.tableName.SYS_USER_PREFE)
        .setFunName(this.srv.globalVar.tableName.SYS_USER_PREFE)
        // .setTableName('test1_user_prefe')
        // .setFunName('test1_user_prefe')
        .setDbType(this.srv.globalVar.dbType.MYSQL)
        .setRule({} as ifs.I_rule);
      const ctdUpdDatas: ifs.I_ctdUpdData[] = [];

      rows.forEach((row, index) => {
        const ctdUpData = new ts.T_ctdUpdData();
        ctdUpData.setDataRule({} as ifs.I_rule).setFileInfo({});
        const changeData = [];
        const filter = { id: row.id };
        changeData.push({ field: 'f_data', value: row.f_data } as ifs.I_fv);
        ctdUpData.setFilter(filter);
        ctdUpData.setRowData(...changeData);
        ctdUpdDatas.push(ctdUpData);
      });
      ctd.setUpdRecDataMany(...ctdUpdDatas);
      this.srv.batRows(ctd).then(resp => {
        const [b, res, msg] = resp;
        if (b) {
          resolve(msg);
          this.getPPConfig();
        } else {
          reject(msg);
        }
      });
    });
  }

  /* 传递主功能名获取当前layout信息 */
  public getLayoutByMainFun(mainFun: string): I_layoutRecord[] {
    for (const key of this.beHaviorData) {
      if (key.mainFunName === mainFun) return key.layoutRecord;
    }
    return [];
  }

  /* 整理并保存layout信息 */
  public saveLayout(layoutInfos: I_layoutInfos[]): Promise<any> {
    return new Promise((resolve, reject) => {
      this.behaviorStatus = true;
      layoutInfos.forEach(layoutInfo => {
        if (this.srv.noValue(this.beHaviorData)) {
          this.beHaviorData = [
            {
              mainFunName: layoutInfo.mainFun,
              funBehaviors: [],
              layoutRecord: layoutInfo.layout
            }
          ];
        } else {
          this.beHaviorData.forEach((item, index: number, arr) => {
            if (
              arr.filter(fun => fun.mainFunName === layoutInfo.mainFun)
                .length === 0
            ) {
              arr.push({
                mainFunName: layoutInfo.mainFun,
                funBehaviors: [],
                layoutRecord: layoutInfo.layout
              });
            } else {
              if (item.mainFunName === layoutInfo.mainFun) {
                item.layoutRecord = layoutInfo.layout;
              }
            }
          });
        }
      });
      this.saveBehaviorData().catch(err => {
        reject(err);
      });
    });
  }

  public removeLayoutByMainFun(mainFun: string) {
    this.beHaviorData.forEach((item, index: number) => {
      if (item.mainFunName === mainFun) item.layoutRecord = [];
    });
    this.behaviorStatus = true;
  }
}
export interface I_personalPreference extends T_personalPreference {}
